﻿// D. Pairs of Segments.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
/*
https://codeforces.com/problemset/problem/1841/D

如果存在至少一个 x，使得 l1≤x≤r1 和 l2≤x≤r2 两条线段 [l1,r1] 和 [l2,r2] 相交。

如果 k 为偶数，且可以将该数组的元素拆分成 k2 对，则数组 [[l1,r1],[l2,r2],...,[lk,rk]]称为优美数组：

数组中的每个元素都恰好属于其中一对；每对中的线段都相互交叉；不同对中的线段不交叉。
例如，数组[[2,4],[9,12],[2,4],[7,7],[10,13],[6,8]]非常漂亮，因为它可以组成如下 3 对：

数组的第一个元素（数据段 [2,4]）和数组的第三个元素（数据段 [2,4]）；
数组的第二个元素（线段 [9,12]）和数组的第五个元素（线段 [10,13]）；
数组的第四个元素（数据段 [7,7]）和第六个元素（数据段 [6,8]）。
正如你所看到的，每一对中的线段都相交，不同对中的线段都不相交。

给你一个包含 n 个线段的数组[[l1,r1],[l2,r2],...,[ln,rn]]。您必须从这个数组中删除尽可能少的元素，这样得到的数组才是美丽的。

输入
第一行包含一个整数 t（1≤t≤1000）--测试用例数。

每个测试用例的第一行包含一个整数 n（2≤n≤2000）--数组中的段数。然后是 n 行，其中第 i 行包含两个整数 li
 和 ri（0≤li≤ri≤109），表示第 i 个线段。

 输入的额外限制：所有测试用例的 n 之和不超过 2000。

输出
对于每个测试用例，打印一个整数 - 你必须删除的最小元素数，这样得到的数组才漂亮。


InputCopy
3
7
2 4
9 12
2 4
7 7
4 8
10 13
6 8
5
2 2
2 8
0 10
1 2
5 6
4
1 1
2 2
3 3
4 4
OutputCopy
1
3
4


注释
在示例的第一个测试用例中，只需删除段数组中的第 5 个元素即可。然后得到数组 [[2,4],[9,12],[2,4],[7,7],[10,13],[6,8]], 非常漂亮。

在示例的第二个测试用例中，可以删除数组的第 1、3 和 4 个元素。然后得到数组[[2,8],[5,6]]，非常漂亮。

在示例的第三个测试用例中，需要删除整个数组。

*/
#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>


using namespace std;
int T;

const int N = 4010;
vector<int> X;
vector<int> lef[N];

int dp[N];

struct NODE {
	int l;
	int r;
}a[N];

int bin(int x) {
	return lower_bound(X.begin(), X.end(), x) - X.begin() +1;
}

void solve() {
	int n; cin >> n;
	for (int i = 1; i <= n; i++) {
		int l, r; cin >> l >> r;
		a[i] = { l,r };
		X.push_back(l); X.push_back(r);
	}

	sort(X.begin(), X.end());
	X.erase(unique(X.begin(),X.end()),X.end());

	for(int i = 1;i<=n;i++)
		for (int j = 1; j < i; j++) {
			int l1 = a[i].l;
			int r1 = a[i].r;
			int l2 = a[j].l;
			int r2 = a[j].r;
			/*auto [l1, r1] = a[i];
			auto [l2, r2] = a[j];*/
			if (max(l1, l2) <= min(r1, r2))
			{
				lef[bin(max(r1, r2))].push_back(bin(min(l1, l2)));
			}
		}

	int m = X.size();
	for (int i = 1; i <= m; i++) {
		dp[i] = dp[i - 1];
		for (const auto& j : lef[i]) {
			dp[i] = max(dp[i], dp[j - 1] + 1);
		}
	}
	cout << n - 2 * dp[m] << endl;
	for (int i = 1; i <= m; i++) lef[i].clear();
	X.clear();
}



int main()
{
	cin >> T;
	while (T--) {
		solve();
	}
	return 0;
}

   